package com.metarnet.topo.dataaccess.oracle;

import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sql.RowSet;

import com.metarnet.topo.dataaccess.abs.AbstractDataAccessFacade;
import com.metarnet.topo.dataaccess.factory.DataBase;
import com.sun.rowset.CachedRowSetImpl;
/**
 * 
 * Oracle数据库操作外观类
 * @author 曹超杰
 * @version 1.0
 */
public class OracleDataAccessFacade extends AbstractDataAccessFacade {
	
	DataBase db;
	private Statement stmt;
	@SuppressWarnings("unused")
	private String dbDriver;
	@SuppressWarnings("unused")
	private String url;
	@SuppressWarnings("unused")
	private String userName;
	@SuppressWarnings("unused")
	private String password;
	
	public OracleDataAccessFacade(String dbDriver, String url, String userName, String password){
		this.dbDriver = dbDriver;
		this.url = url;
		this.userName = userName;
		this.password = password;
		
		this.db = new DataBase(dbDriver, url, userName, password);
		
//		this.sqlShareData = new OracleSqlShareData();
//		this.sqlAlarm = new OracleSqlAlarm();
//		this.sqlAppliction = new OracleSqlApplication();
//		this.sqlCommonSupport = new OracleSqlCommonSupport();
//		this.sqlEnhancedTool = new OracleSqlEnhancedTools();
//		this.sqlGeneralRes = new OracleSqlGeneralRes();
//		this.sqlMainFW = new OracleSqlMainFW();
//		this.sqlPerfmance = new OracleSqlPerfmance();
//		this.sqlSecurity = new OracleSqlSecurity();
//		this.sqlSelf = new OracleSqlSelf();
//		this.sqlSystem = new OracleSqlSystem();
//		this.sqlTopo = new OracleSqlTopo();
//		this.sqlPortal = new OracleSqlPortal();
		//this.sqlDial = new OracleSqlDial();
	}
	
	
	/**
	 * 执行非查询操作
	 * @param sqlString
	 */
	public boolean executeNonQuery(String sqlString) {
		boolean result = false;
		int i = getNonQueryRowCount(sqlString);
		if(i!=0){
			result = true;
		}	
		return result;

	}
	
	
	
	/**
	 * 获取执行非查询操作影响行数
	 * @param sqlString
	 * @return
	 */
	public int getNonQueryRowCount(String sqlString){
		int result = 0;
		Connection conn = null;
		
		try {
			// 取得数据库连接器
			conn = db.getConnection();
			// 简单声明（连接器有两种调用SQL的方法：简单声明与预编译声明）
			stmt = conn.createStatement();
			// 查询操作（JDBC提供两种操作：查询操作与更新操作）
			result = stmt.executeUpdate(sqlString);	
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {			
				if(stmt!=null)
				{
					stmt.close();	
				}
				if(conn!=null)
				{
					// 关闭数据库链接
					conn.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}			
		}	
		return result;
	}
	
	
	
	
	/**
	 * 获取执行查询操作影响行数
	 * @param sqlString
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public int getQueryRowCount(String sqlString){
		int result = 0;
		List list = getList(sqlString);
		if(list!=null){
			result = list.size(); 
		}
		return result;
	}
	
	/**
	 * 通过查询字符串返回List数据集
	 * @param sqlString 
	 */
	@SuppressWarnings("unchecked")
	public List getList(String sqlString) {
		return getList(sqlString, 0, 0);
	}

	/**
	 * 通过查询字符串和页大小返回List数据集
	 * @param sqlString
	 * @param pageSize 
	 * @param pageNum
	 */
	@SuppressWarnings("unchecked")
	public List getList(String sqlString, int pageSize, int pageNum) {
        List list=new ArrayList();
        RowSet rowSet;
		
		try {	
				rowSet = getRowSet(sqlString, pageSize, pageNum);
			
				while(rowSet.next())
				{
					Map map = new HashMap();
					for(int i=1;i<=rowSet.getMetaData().getColumnCount();i++)
					{
						map.put(rowSet.getMetaData().getColumnName(i), rowSet.getString(i));
					}
					list.add(map);
				}				
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
		}
		return list;

	}

	
	
	/**
	 * 通过查询字符串返回RowSet数据集
	 * @param sqlString
	 */
	public RowSet getRowSet(String sqlString) throws SQLException {
		return getRowSet(sqlString, 0, 0);
	}
	
	

	/**
	 * 通过查询字符串和页大小返回RowSet数据集
	 * @param sqlString
	 * @param pageSize 
	 * @param pageNum
	 */
	public RowSet getRowSet(String sqlString, int pageSize, int pageNum) throws SQLException {
		
        ResultSet rs = null;
        Connection conn = null;
        CachedRowSetImpl rowSet = new CachedRowSetImpl();
		
		try {	
			// 取得数据库连接器
			conn = db.getConnection();
			// 简单声明（连接器有两种调用SQL的方法：简单声明与预编译声明）
			stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
			// 查询操作（JDBC提供两种操作：查询操作与更新操作）
			rs = stmt.executeQuery(sqlString);

			if(pageSize > 0 && pageNum > 0){
				rowSet.setPageSize(pageSize);
				int skip = (pageNum - 1) * pageSize + 1;
				rowSet.populate(rs, skip);
//				rowSet.populate(new ResultSetWrapper(rs), skip);
			}
			else{
				rowSet.populate(rs);
//				rowSet.populate(new ResultSetWrapper(rs));
			}

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				if(rs!=null)
				{				
					rs.close();					
				}
				if(stmt!=null)
				{
					stmt.close();	
				}
				if(conn!=null)
				{
					// 关闭数据库链接
					conn.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return rowSet;
	}
	
	
	
	
	/**
	 * 开启事务，返回开启了事务的连接
	 */
	public Connection beginTransaction()
	{
		 Connection conn = null;
		 try {	
				// 取得数据库连接器
				conn = db.getConnection();
				 //设置不自动提交，相当于开启了事务
	            conn.setAutoCommit(false);
	            //设置JDBC事务的级别
	            conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE); 
	            
	            System.out.println("beginTransaction");
				
		 }
		 catch (Exception e) {
				e.printStackTrace();
				try
				{
					if(conn!=null)
					{
						// 关闭数据库链接
						conn.close();
					}
				} catch (Exception ex) {
					e.printStackTrace();
				}
				conn = null;
		 }
		 
		 return conn;
	}
	
	/**
	 * 提交事务
	 * @param conn 事务所在的连接
	 */
	public void commitTransaction(Connection conn)
	{
		try
		{
			conn.commit();
			System.out.println("commitTransaction");
		}
		catch (Exception e) {
			e.printStackTrace();
		 }finally{
				try {
					if(conn!=null)
					{
						// 关闭数据库链接
						conn.close();
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
		 }
	}
	
	/**
	 * 回滚事务
	 * @param conn 事务所在的连接
	 */
	public void roolbackTransaction(Connection conn)
	{
		try
		{
			// 当本事务中的插入和更新SQL其中一个执行异常的时候，整个事务回滚 
			conn.rollback();
			System.out.println("roolbackTransaction");
		}
		catch (Exception e) {
			e.printStackTrace();
		 }finally{
				try {
					if(conn!=null)
					{
						// 关闭数据库链接
						conn.close();
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
		 }
	}


	/**
	 * 事务中执行非查询操作，执行完成后不关闭连接
	 * @param sqlString
	 */
	public boolean executeNonQueryInTransaction(String sqlString,Connection conn) {
		boolean result = false;
		int i = getNonQueryRowCountInTransaction(sqlString,conn);
		if(i!=0){
			result = true;
		}	
		return result;

	}
	
	/**
	 * 事务中获取执行非查询操作影响行数，执行完成后不关闭连接
	 * @param sqlString
	 * @return
	 */
	public int getNonQueryRowCountInTransaction(String sqlString,Connection conn){
		int result = 0;
		
		try {
			// 简单声明（连接器有两种调用SQL的方法：简单声明与预编译声明）
			stmt = conn.createStatement();
			// 查询操作（JDBC提供两种操作：查询操作与更新操作）
			result = stmt.executeUpdate(sqlString);	
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {			
				if(stmt!=null)
				{
					stmt.close();	
				}
			} catch (Exception e) {
				e.printStackTrace();
			}			
		}	
		return result;
	}
	
	/**
	 * 事务中通过查询字符串返回RowSet数据集，完成后不关闭连接
	 * @param sqlString
	 */
	public RowSet getRowSetInTransaction(String sqlString,Connection conn) throws SQLException {
		return getRowSetInTransaction(sqlString, 0, 0,conn);
	}
	
	/**
	 * 事务中通过查询字符串和页大小返回RowSet数据集，完成后不关闭连接
	 * @param sqlString
	 * @param pageSize 
	 * @param pageNum
	 */
	public RowSet getRowSetInTransaction(String sqlString, int pageSize, int pageNum,Connection conn) throws SQLException {
		
        ResultSet rs = null;
        CachedRowSetImpl rowSet = new CachedRowSetImpl();
		
		try {	
			// 简单声明（连接器有两种调用SQL的方法：简单声明与预编译声明）
			stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
			// 查询操作（JDBC提供两种操作：查询操作与更新操作）
			rs = stmt.executeQuery(sqlString);

			if(pageSize > 0 && pageNum > 0){
				rowSet.setPageSize(pageSize);
				int skip = (pageNum - 1) * pageSize + 1;
				rowSet.populate(rs, skip);
//				rowSet.populate(new ResultSetWrapper(rs), skip);
			}
			else{
				rowSet.populate(rs);
//				rowSet.populate(new ResultSetWrapper(rs));
			}

		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				if(rs!=null)
				{				
					rs.close();					
				}
				if(stmt!=null)
				{
					stmt.close();	
				}
				
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return rowSet;
	}

}